home *** CD-ROM | disk | FTP | other *** search
/ SGI Varsity Update 1998 August / SGI Varsity Update 1998 August.iso / dist / dist6.5 / il_dev.idb / usr / include / il / ilPolyDef.h.z / ilPolyDef.h
C/C++ Source or Header  |  1998-07-29  |  10KB  |  290 lines
  1. #if 0 
  2.  
  3.     Copyright (c) 1991 SGI   All Rights Reserved
  4.     THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF SGI
  5.     The copyright notice above does not evidence any
  6.     actual or intended publication of such source code,
  7.     and is an unpublished work by Silicon Graphics, Inc.
  8.     This material contains CONFIDENTIAL INFORMATION that
  9.     is the property of Silicon Graphics, Inc. Any use,
  10.     duplication or disclosure not specifically authorized
  11.     by Silicon Graphics is strictly prohibited.
  12.     
  13.     RESTRICTED RIGHTS LEGEND:
  14.     
  15.     Use, duplication or disclosure by the Government is
  16.     subject to restrictions as set forth in subdivision
  17.     (c)(1)(ii) of the Rights in Technical Data and Computer
  18.     Software clause at DFARS 52.227-7013, and/or in similar
  19.     or successor clauses in the FAR, DOD or NASA FAR
  20.     Supplement.  Unpublished- rights reserved under the
  21.     Copyright Laws of the United States.  Contractor is
  22.     SILICON GRAPHICS, INC., 2011 N. Shoreline Blvd.,
  23.     Mountain View, CA 94039-7311
  24.  
  25. #endif
  26.  
  27. #ifndef _ilPolyDef_h_
  28. #define _ilPolyDef_h_
  29.  
  30. /*    Defines some nice little structures and methods for polynomials.
  31.  *
  32.  * Note: this file is included by C code so general comments must use
  33.  *       the C commenting convention.
  34.  *
  35.  * Contents:
  36.  *    ilPolyCoeff1D:    coefficients for univariate 7th-degree polynomial
  37.  *    ilPolyCoeff2D:    coefficients for bivariate 7th-degree polynomial
  38.  *    ilPoly1D:    univariate 7th-degree polynomial
  39.  *    ilPoly2D:    bivariate 7th-degree polynomial
  40.  *    ilAffine2D:    bivariate 1st-degree polynomial
  41.  *
  42.  */
  43.  
  44. #include <ifl/iflCoord.h>
  45.  
  46. #ifdef __cplusplus
  47. struct ilPoly2D;        // forward reference
  48. #endif
  49.  
  50. /* 
  51.  *   Coefficients for seventh degree univariate polynomials:
  52.  */
  53. struct ilPolyCoeff1D { float con, x, x2, x3, x4, x5, x6, x7; };
  54.  
  55. /* 
  56.  *   Coefficients for seventh degree bivariate polynomials:
  57.  */
  58. struct ilPolyCoeff2D {
  59.     float con,
  60.         y, x,
  61.         y2, xy, x2,
  62.         y3, xy2, x2y, x3,
  63.         y4, xy3, x2y2, x3y, x4,
  64.         y5, xy4, x2y3, x3y2, x4y, x5,
  65.         y6, xy5, x2y4, x3y3, x4y2, x5y, x6,
  66.         y7, xy6, x2y5, x3y4, x4y3, x5y2, x6y, x7;
  67. };
  68.  
  69. /*
  70.  * Univariate polynomials in X up to degree 7.
  71.  *
  72.  *     p(X) = x_deg*X^deg + ... + x*X + con
  73.  */
  74. struct ilPoly1D  {
  75.     int degree;            /* degree of polynomial */
  76.     struct ilPolyCoeff1D c;    /* polynomial coefficients (up to 7) */
  77.     
  78. #ifdef __cplusplus
  79.     enum { maxDegree = 7 };    // maximum degree polynomials supported
  80.     //ilPoly1D() {}        // null constructor
  81.  
  82.     // Construct a one-variable polynomial in X from a two-variable
  83.     // polynomial in X and Y given a specified Y value.
  84.     //
  85.     ilPoly1D(const ilPoly2D &cf, double y);
  86. #endif /* __cplusplus */
  87. };
  88.  
  89.  
  90. /* First degree, two-variable polynomials in X and Y:
  91.  *
  92.  *     p(X, Y) = x*X + y*Y + con
  93.  */
  94.  
  95. struct ilAffine2D {
  96.     float con,            /* polynomial constant coefficient */
  97.           y,  x;        /* polynomial first degree coefficients */
  98. #ifdef __cplusplus
  99.     ilAffine2D() {}        // null constructor
  100.  
  101.     // Construct a first degree polynomial given all of its coefficients.
  102.     //
  103.     ilAffine2D(float Con, float X, float Y) { init(Con, X, Y); }
  104.  
  105.     // Construct a first degree polynomial from a general Nth degree
  106.     // polynomial.  We have to defer the actual definition until after the
  107.     // definition of the general Nth degree polynomial class so we can
  108.     // implement an inlined version.
  109.     //
  110.     inline ilAffine2D(const ilPoly2D &uc);
  111.  
  112.     // Initialize a first degree polynomial given all of its coefficients.
  113.     //
  114.     ilAffine2D &init(float Con, float X, float Y)
  115.     { con = Con; x = X; y = Y; return *this; }
  116.  
  117.     // Assign a general Nth degree polynomial to a first degree polynomial.
  118.     // Defer definition till after definition of Nth degree polynomial class.
  119.     //
  120.     inline ilAffine2D &operator=(const ilPoly2D& uc);
  121.  
  122.     // Need to define the first degree to first degree assignment operator
  123.     // now since the above assignment operator definition losses us the
  124.     // default one the C++ normally gives us ...
  125.     //
  126.     ilAffine2D &operator=(const ilAffine2D& uc)
  127.     { return init(uc.con, uc.x, uc.y); }
  128.  
  129.     // Create the identity polynomial for variable ``dim'' where dim is equal
  130.     // to either 'x' or 'y'.  The resulting polynomial will translate p(X, Y)
  131.     // to X or Y, respectively.
  132.     //
  133.     ilAffine2D &identity(char dim)
  134.     { return init(0.0, dim == 'x', dim == 'y'); }
  135.  
  136.     // Return result of evaluating the polynomial for (u, v).
  137.     //
  138.     float operator()(double u, double v) const
  139.     { return x*u + y*v + con; }
  140.     float operator()(const iflXYdouble &uv) const
  141.     { return x*uv.x + y*uv.y + con; }
  142.     float operator()(const iflXYfloat &uv) const
  143.     { return (double)x*uv.x + (double)y*uv.y + con; }
  144.  
  145.     // Return the functional composition of this polynomial with two other
  146.     // first degree two-variable polinomials:
  147.     //
  148.     //     this(uc(r, s), vc(r, s))
  149.     //
  150.     ilAffine2D operator()(const ilAffine2D &uc, const ilAffine2D &vc) const
  151.     {
  152.     // note: calculate all the new coefficients in double precision
  153.     return ilAffine2D((double)x*uc.con + (double)y*vc.con + con,
  154.                (double)x*uc.x + (double)y*vc.x,
  155.                (double)x*uc.y + (double)y*vc.y);
  156.     }
  157.  
  158.     // Form the functional composition of this polynomial with two other Nth
  159.     // degree two-variable polinomials and store the result as our new
  160.     // polynomial coefficients.  Return a reference to this.
  161.     //
  162.     //     this'(r, s) = this(uc(r, s), vc(r, s))
  163.     //
  164.     ilAffine2D &compose(const ilAffine2D &uc, const ilAffine2D &vc)
  165.     {
  166.     // XXX must generate intermediate result instead of simply passing
  167.     // XXX new coefficients to inlined init() method since a bug in the
  168.     // XXX compiler (#262091) causes new coefficients to be stored before
  169.     // XXX completely evaluating all the new coefficients.
  170.     // note: calculate all the new coefficients in double precision
  171.     ilAffine2D result((double)x*uc.con + (double)y*vc.con + con,
  172.                (double)x*uc.x + (double)y*vc.x,
  173.                (double)x*uc.y + (double)y*vc.y);
  174.     *this = result;
  175.     return *this;
  176.     }
  177. #endif /* __cplusplus */
  178. };
  179.  
  180. /* General two-variable polynomials in X and Y up to degree 7.
  181.  *
  182.  *     p(X, Y) = x_deg*X^deg + y_deg*Y^deg + ... + x*X + y*Y + con
  183.  */
  184. struct ilPoly2D {
  185.     int degree;            /* degree of polynomial */
  186.     struct ilPolyCoeff2D c;    /* polynomial coefficients (up to 7) */
  187.  
  188. #ifdef __cplusplus
  189.     enum { maxDegree = 7 };    // maximum degree polynomials supported
  190.     ilPoly2D() {}        // null constructor
  191.  
  192.     // Construct general two-variable polynomial from a first degree
  193.     // two-variable polynomial.  Note that this constructor depends on
  194.     // the mapping for the storage for the various polynomials to be the
  195.     // same.
  196.     //
  197.     ilPoly2D(const ilAffine2D &uc) { degree = 1; *(ilAffine2D *)&c = uc; }
  198.  
  199.     // Do the same thing for assignments from first degree two-variable
  200.     // polynomials.
  201.     //
  202.     ilPoly2D &operator=(const ilAffine2D &uc)
  203.     { degree = 1; *(ilAffine2D *)&c = uc; return *this; }
  204.  
  205.     // Need to define the Nth degree to Nth degree assignment operator
  206.     // now since the above assignment operator definition losses us the
  207.     // default one the C++ normally gives us ...
  208.     //
  209.     const ilPoly2D &operator=(const ilPoly2D &uc)
  210.     { degree = uc.degree; c = uc.c; return *this; }
  211.  
  212.     // Create the identity polynomial for variable ``dim'' where dim is equal
  213.     // to either 'x' or 'y'.  The resulting polynomial with translate p(X, Y)
  214.     // to X or Y, respectively.
  215.     //
  216.     ilPoly2D &identity(char dim)
  217.     {
  218.         degree = 1;
  219.         c.con = 0.0;
  220.         c.x = (float)(dim=='x');
  221.         c.y = (float)(dim=='y');
  222.         return *this;
  223.     }
  224.  
  225.     // Return result of evaluating the polynomial for (u, v).
  226.     //
  227.     float operator()(double u, double v) const;
  228.     float operator()(const iflXYdouble &uv) const
  229.     { return operator()(uv.x, uv.y); }
  230.     float operator()(const iflXYfloat &uv) const
  231.     { return operator()(uv.x, uv.y); }
  232.  
  233.     // Return the X and Y derivatives, respectively, of the polynomial at
  234.     // point (x,y).
  235.     //
  236.     float dx(double u, double v) const;
  237.     float dx(const iflXYdouble& uv) const
  238.     { return dx(uv.x, uv.y); }
  239.     float dx(const iflXYfloat& uv) const
  240.     { return dx(uv.x, uv.y); }
  241.  
  242.     float dy(double u, double v) const;
  243.     float dy(const iflXYdouble& uv) const
  244.     { return dy(uv.x, uv.y); }
  245.     float dy(const iflXYfloat& uv) const
  246.     { return dy(uv.x, uv.y); }
  247.  
  248.     // Return the functional composition of this polynomial with two other
  249.     // Nth degree two-variable polinomials:
  250.     //
  251.     //     this(uc(X, Y), vc(X, Y))
  252.     //
  253.     ilPoly2D operator()(const ilPoly2D &uc, const ilPoly2D &vc) const;
  254.  
  255.     // Form the functional composition of this polynomial with two other Nth
  256.     // degree two-variable polinomials and store the result as our new
  257.     // polynomial coefficients.  Return a reference to this.
  258.     //
  259.     //     this'(X, Y) = this(uc(X, Y), vc(X, Y))
  260.     //
  261.     ilPoly2D &compose(const ilPoly2D &uc, const ilPoly2D &vc);
  262.  
  263.     // Return TRUE if the other polynomial is equal to this one and FALSE
  264.     // otherwise.
  265.     //
  266.     int operator==(const ilPoly2D &rhs) const;
  267.     int operator!=(const ilPoly2D &rhs) const { return !(*this == rhs); }
  268. #endif /* __cplusplus */
  269. };
  270.  
  271. #ifdef __cplusplus
  272. inline ilAffine2D::ilAffine2D(const ilPoly2D &uc) { *this = uc; }
  273.  
  274. inline ilAffine2D& ilAffine2D::operator=(const ilPoly2D& uc)
  275. {
  276.     return init(uc.c.con, uc.degree == 0 ? 0.0 : uc.c.x,
  277.               uc.degree == 0 ? 0.0 : uc.c.y); 
  278. }
  279. #endif
  280.  
  281. #ifndef __cplusplus
  282. typedef struct ilPolyCoeff1D ilPolyCoeff1D;
  283. typedef struct ilPoly1D ilPoly1D;
  284. typedef struct ilAffine2D ilAffine2D;
  285. typedef struct ilPolyCoeff2D ilPolyCoeff2D;
  286. typedef struct ilPoly2D ilPoly2D;
  287. #endif /* __cplusplus */
  288.  
  289. #endif /* _ilPolyDef_h_ */
  290.